Clover coverage report - Prayer Portlets - 0.1-rc4-SNAPSHOT
Coverage timestamp: Thu Aug 19 2004 18:34:34 EDT
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 197   Methods: 19
NCLOC: 152   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 Source file Conditionals Statements Methods TOTAL
DefaultIndexProvider.java 84.4% 97.1% 94.7% 93.4%
coverage coverage
 1    
 package org.marketchangers.prayer.lucene;
 2    
 
 3    
 import java.io.IOException;
 4    
 import java.util.Collection;
 5    
 import java.util.Date;
 6    
 import java.util.Iterator;
 7    
 
 8    
 import org.apache.lucene.analysis.Analyzer;
 9    
 import org.apache.lucene.document.DateField;
 10    
 import org.apache.lucene.document.Document;
 11    
 import org.apache.lucene.document.Field;
 12    
 import org.apache.lucene.index.IndexReader;
 13    
 import org.apache.lucene.index.IndexWriter;
 14    
 import org.apache.lucene.index.Term;
 15    
 import org.apache.lucene.queryParser.MultiFieldQueryParser;
 16    
 import org.apache.lucene.queryParser.ParseException;
 17    
 import org.apache.lucene.search.BooleanQuery;
 18    
 import org.apache.lucene.search.IndexSearcher;
 19    
 import org.apache.lucene.search.Query;
 20    
 import org.apache.lucene.search.RangeQuery;
 21    
 import org.apache.lucene.search.Searcher;
 22    
 import org.apache.lucene.search.TermQuery;
 23    
 import org.apache.lucene.store.Directory;
 24    
 import org.marketchangers.prayer.PrayerRequest;
 25    
 import org.marketchangers.prayer.PrayerRequestQuery;
 26    
 
 27    
 /**
 28    
  * @author <a href="mailto:mtodd@wc-group.com">Matthew Todd</a>
 29    
  */
 30    
 public class DefaultIndexProvider implements IndexProvider {
 31    
     private Directory directory;
 32    
     private Analyzer analyzer;
 33    
 
 34  44 
     public DefaultIndexProvider(Directory directory, Analyzer analyzer) {
 35  44 
         this.directory = directory;
 36  44 
         this.analyzer = analyzer;
 37    
     }
 38    
 
 39  14 
     public IndexReader getReader() throws IOException {
 40  14 
         return IndexReader.open(directory);
 41    
     }
 42    
 
 43  26 
     public Searcher getSearcher() throws IOException {
 44  26 
         return new IndexSearcher(directory);
 45    
     }
 46    
 
 47  38 
     public IndexWriter getWriter() throws IOException {
 48  38 
         return new IndexWriter(directory, analyzer, shouldCreate());
 49    
     }
 50    
 
 51  38 
     private boolean shouldCreate() throws IOException {
 52  38 
         return directory.list().length == 0;
 53    
     }
 54    
 
 55    
     /**
 56    
      * Categories are stored by name, so searches should sumbit category name,
 57    
      * not id. This also means that category searches may be "looser" than
 58    
      * intended, due to stemming, though they are stored as Keywords, so maybe
 59    
      * not.
 60    
      */
 61  24 
     public Document translateToDocument(PrayerRequest request) {
 62  24 
         Document document = new Document();
 63    
 
 64  24 
         keyword(document, "category", request.getCategory());
 65  24 
         keyword(document, "endDate", request.getEndDate());
 66  24 
         keyword(document, "id", request.getId());
 67  24 
         keyword(document, "requestorUserId", request.getRequestorUserId());
 68  24 
         keyword(document, "startDate", request.getStartDate());
 69  24 
         keyword(document, "status", request.getStatus());
 70    
 
 71  24 
         unstored(document, "background", request.getBackground());
 72  24 
         unstored(document, "content", request.getContent());
 73  24 
         unstored(document, "subject", request.getSubject());
 74    
 
 75  24 
         keyword(document, "catchAll", "catchAll");
 76    
 
 77  24 
         return document;
 78    
     }
 79    
 
 80  72 
     private void unstored(Document d, String name, Object value) {
 81  72 
         if (value != null)
 82  66 
             d.add(Field.UnStored(name, value.toString()));
 83    
     }
 84    
 
 85  48 
     private void keyword(Document d, String name, Date value) {
 86  48 
         if (value != null)
 87  44 
             d.add(Field.Keyword(name, value));
 88    
     }
 89    
 
 90  120 
     private void keyword(Document d, String name, Object value) {
 91  120 
         if (value != null) {
 92  100 
             d.add(Field.Keyword(name, value.toString()));
 93    
         } else {
 94  20 
             d.add(Field.Keyword(name, ""));
 95    
         }
 96    
     }
 97    
 
 98  22 
     public Query translateToQuery(PrayerRequestQuery q) {
 99  22 
         BooleanQuery query = new BooleanQuery();
 100    
 
 101  22 
         if (q.hasCategoryName()) {
 102  6 
             query.add(categoryName(q.getCategoryName()), true, false);
 103    
         }
 104  22 
         if (q.hasEndDate()) {
 105  16 
             query.add(endDate(q.getEndDate()), true, false);
 106    
         }
 107  22 
         if (q.hasRequestorUserIds()) {
 108  20 
             query.add(requestorUserIds(q.getRequestorUserIds()), true, false);
 109    
         }
 110  22 
         if (q.hasSearchTerms()) {
 111  6 
             query.add(searchTerms(q.getSearchTerms()), true, false);
 112    
         }
 113  22 
         if (q.hasStartDate()) {
 114  16 
             query.add(startDate(q.getStartDate()), true, false);
 115    
         }
 116  22 
         if (q.hasStatus()) {
 117  6 
             query.add(status(q.getStatus()), true, false);
 118    
         }
 119    
 
 120  22 
         return query;
 121    
     }
 122    
 
 123  6 
     public Query translateToQuery(PrayerRequest r) {
 124  6 
         BooleanQuery query = new BooleanQuery();
 125    
 
 126  6 
         if (r.getCategory() != null) {
 127  4 
             if (r.getCategory().getName() != null) {
 128  4 
                 query.add(categoryName(r.getCategory().getName()), true, false);
 129    
             }
 130    
         }
 131    
 
 132  6 
         if (r.getEndDate() != null) {
 133  6 
             query.add(endDate(r.getEndDate()), true, false);
 134    
         }
 135  6 
         if (r.getRequestorUserId() != null) {
 136  6 
             query.add(requestorUserId(r.getRequestorUserId()), true, false);
 137    
         }
 138  6 
         if (r.getContent() != null) {
 139  6 
             query.add(searchTerms(r.getContent()), true, false);
 140    
         }
 141  6 
         if (r.getStartDate() != null) {
 142  6 
             query.add(startDate(r.getStartDate()), true, false);
 143    
         }
 144    
 
 145  6 
         return query;
 146    
     }
 147    
 
 148    
     // ------------------------------------------------- Query-Building Methods
 149  0 
     private Query all() {
 150  0 
         return new TermQuery(new Term("catchAll", "catchAll"));
 151    
     }
 152    
 
 153  10 
     private Query categoryName(String categoryName) {
 154  10 
         return new TermQuery(new Term("category", categoryName));
 155    
     }
 156    
 
 157  22 
     private Query endDate(Date date) {
 158  22 
         Term upperTerm = new Term("endDate", DateField.dateToString(date));
 159  22 
         return new RangeQuery(null, upperTerm, true);
 160    
     }
 161    
 
 162  26 
     private Query requestorUserId(String requestorUserId) {
 163  26 
         return new TermQuery(new Term("requestorUserId", requestorUserId));
 164    
     }
 165    
 
 166  20 
     private Query requestorUserIds(Collection requestors) {
 167  20 
         BooleanQuery query = new BooleanQuery();
 168    
 
 169  20 
         Iterator requestorUserIds = requestors.iterator();
 170  20 
         while (requestorUserIds.hasNext()) {
 171  20 
             String requestorUserId = (String) requestorUserIds.next();
 172  20 
             query.add(requestorUserId(requestorUserId), false, false);
 173    
         }
 174    
 
 175  20 
         return query;
 176    
     }
 177    
 
 178  12 
     private Query searchTerms(String searchTerms) {
 179  12 
         String[] fields = { "background", "content", "subject" };
 180    
 
 181  12 
         try {
 182  12 
             return MultiFieldQueryParser.parse(searchTerms, fields, analyzer);
 183    
         } catch (ParseException pe) {
 184  0 
             return all();
 185    
         }
 186    
     }
 187    
 
 188  22 
     private Query startDate(Date date) {
 189  22 
         Term lowerTerm = new Term("startDate", DateField.dateToString(date));
 190  22 
         return new RangeQuery(lowerTerm, null, true);
 191    
     }
 192    
 
 193  6 
     private Query status(String status) {
 194  6 
         return new TermQuery(new Term("status", status));
 195    
     }
 196    
 }
 197    
 
 
CloverReport generated by Clover v1.2.3
Thu Aug 19 2004 18:34:35 EDT.		   30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it.